package com.smartTerminal.utils;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;

/**
 * 字符串操作工具类
 * @author lancelot
 * @Date 2018/01/06 15:12
 * @Version 1.0
 *
 */
public class StringUtils {

	final static Logger logger = Logger.getLogger (StringUtils.class);
	public final static String ENCODING = "GBK";
	private static String[] strArray = new String[] { "a", "b", "c", "d", "e",  
	         "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r",  
	         "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E",  
	        "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",  
	         "S", "T", "U", "V", "W", "X", "Y", "Z", "0", "1", "2", "3", "4",  
	         "5", "6", "7", "8", "9", "!", "@", "#", "$", "%", "^", "&", "(",  
	         ")" }; 
	
	
    /**
     * 首字母变小写
     * @param str
     * @return
     */
    public static String firstCharToLowerCase(String str) {
        char firstChar = str.charAt(0);
        if (firstChar >= 'A' && firstChar <= 'Z') {
            char[] arr = str.toCharArray();
            arr[0] += ('a' - 'A');
            return new String(arr);
        }
        return str;
    }

    /**
     * 首字母变大写
     * @param str
     * @return
     */
    public static String firstCharToUpperCase(String str) {
        char firstChar = str.charAt(0);
        if (firstChar >= 'a' && firstChar <= 'z') {
            char[] arr = str.toCharArray();
            arr[0] -= ('a' - 'A');
            return new String(arr);
        }
        return str;
    }

    /**
     * 判断是否为空
     * @param str
     * @return
     */
    public static boolean isEmpty(final String str) {
        return (str == null) || (str.length() == 0);
    }

    /**
     * 判断是否不为空
     * @param str
     * @return
     */
    public static boolean isNotEmpty(final String str) {
        return !isEmpty(str);
    }

    
    public static boolean isNullOrEmpty (String str){
	  if (str== null ||
	    "".equals(str))
	   return true;
	  else
	   return false;
	  
	 }
	 public static String nullToEmpty(String str){
	  if (str== null)
	   return "";
	   return str;
	  
	 }
	 public static String getEscaped(String str ){
	  try {
	   return URLEncoder.encode(str, ENCODING);
	  } catch (UnsupportedEncodingException e) {
	   logger.warn("", e);
	  }
	  return "";
	 }
	 
	 /**
	  * 校验手机号码
	  * @param num
	  * @return
	  *
	  */
	 public static boolean IsMobileCode(String code)
	 {
	  String Code = "[0-9]{3}";
	  if(isNumeric(code,Code))
	   return true;
	  else 
	   return false;
	 }
	 public static boolean IsMobileNum1(String num){
	   String HK="[0-9]{8}";
	   String MainLand="[0-9]{11}";
	//   String USA="";
	  if( (isNumeric(num,HK)==true || isNumeric(num,MainLand)==true ) && num.matches("^(13|15|18)\\d{9}$"))
	   return true;
	  else
	   return false;
	 }
	 
	 public static boolean IsMoblieNum(String num)
	 {
	   String Code="[0-9]{1,4}";
	   String HK="[0-9]{8}";
	   String MainLand="[0-9]{11}";
	  if(num.trim()!=null || num.trim()!="")
	  {
	   String[] str=num.split(" ");
	   if(isNumeric(str[0],Code))
	   {
	    if((isNumeric(str[1],HK)==true || isNumeric(str[1],MainLand)==true) && str[1].matches("^(13|15|18)\\d{6，9}$"))
	    {
	     
	    return true;
	    }
	    else
	    {
	     return false;
	    }
	   }
	   else
	   {
	    return false;
	   }
	  }
	  else
	  {
	   return false;
	  }
	 }

	 public static  boolean isNumeric(String str,String where )
	 {
	  Pattern pattern = Pattern.compile(where);
	  Matcher isNum = pattern.matcher(str);
	   if( !isNum.matches() )
	   {
	   return false;
	   }
	  return true;
	 }
	  
	  /** 
	  * 生成唯一字符串  
	  * @param length 需要长度 
	  * @param symbol 是否允许出现特殊字符 -- !@ $%^&*() 
	  * @return 
	  */  
	  public static String getUniqueString(int length, boolean symbol)  
	        throws Exception {  
	    Random ran = new Random();  
	    int num = ran.nextInt(61);  
	    String returnString = "";  
	    String str = "";  
	    for (int i = 0; i < length;) {  
	        if (symbol)  
	            num = ran.nextInt(70);  
	        else  
	            num = ran.nextInt(61);  
	        str = strArray[num];  
	        if (!(returnString.indexOf(str) >= 0)) {  
	            returnString += str;  
	            i++;  
	        }  
	    }  
	    return returnString;  
	  }  
    
    /**
     * 判断是否空白
     * @param str
     * @return
     */
    public static boolean isBlank(final String str) {
        int strLen;
        if ((str == null) || ((strLen = str.length()) == 0))
            return true;
        for (int i = 0; i < strLen; i++) {
            if (!Character.isWhitespace(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断是否不是空白
     * @param str
     * @return
     */
    public static boolean isNotBlank(final String str) {
        return !isBlank(str);
    }

    /**
     * 判断多个字符串全部是否为空
     * @param strings
     * @return
     */
    public static boolean isAllEmpty(String... strings) {
        if (strings == null) {
            return true;
        }
        for (String str : strings) {
            if (isNotEmpty(str)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断多个字符串其中任意一个是否为空
     * @param strings
     * @return
     */
    public static boolean isHasEmpty(String... strings) {
        if (strings == null) {
            return true;
        }
        for (String str : strings) {
            if (isEmpty(str)) {
                return true;
            }
        }
        return false;
    }

    /**
     * checkValue为 null 或者为 "" 时返回 defaultValue
     * @param checkValue
     * @param defaultValue
     * @return
     */
    public static String isEmpty(String checkValue, String defaultValue) {
        return isEmpty(checkValue) ? defaultValue : checkValue;
    }

    /**
     * 字符串不为 null 而且不为 "" 并且等于other
     * @param str
     * @param other
     * @return
     */
    public static boolean isNotEmptyAndEquelsOther(String str, String other) {
        if (isEmpty(str)) {
            return false;
        }
        return str.equals(other);
    }

    /**
     * 字符串不为 null 而且不为 "" 并且不等于other
     * @param str
     * @param other
     * @return
     */
    public static boolean isNotEmptyAndNotEquelsOther(String str, String... other) {
        if (isEmpty(str)) {
            return false;
        }
        for (int i = 0; i < other.length; i++) {
            if (str.equals(other[i])) {
                return false;
            }
        }
        return true;
    }

    /**
     * 字符串不等于other
     * @param str
     * @param other
     * @return
     */
    public static boolean isNotEquelsOther(String str, String... other) {
        for (int i = 0; i < other.length; i++) {
            if (other[i].equals(str)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断字符串不为空
     * @param strings
     * @return
     */
    public static boolean isNotEmpty(String... strings) {
        if (strings == null) {
            return false;
        }
        for (String str : strings) {
            if (str == null || "".equals(str.trim())) {
                return false;
            }
        }
        return true;
    }

    /**
     * 比较字符相等
     * @param value
     * @param equals
     * @return
     */
    public static boolean equals(String value, String equals) {
        if (isAllEmpty(value, equals)) {
            return true;
        }
        return value.equals(equals);
    }

    /**
     * 比较字符串不相等
     * @param value
     * @param equals
     * @return
     */
    public static boolean isNotEquals(String value, String equals) {
        return !equals(value, equals);
    }

    public static String[] split(String content, String separatorChars) {
        return splitWorker(content, separatorChars, -1, false);
    }

    public static String[] split(String str, String separatorChars, int max) {
        return splitWorker(str, separatorChars, max, false);
    }

    public static final String[] EMPTY_STRING_ARRAY = new String[0];

    private static String[] splitWorker(String str, String separatorChars, int max, boolean preserveAllTokens) {
        if (str == null) {
            return null;
        }
        int len = str.length();
        if (len == 0) {
            return EMPTY_STRING_ARRAY;
        }
        List<String> list = new ArrayList<String>();
        int sizePlus1 = 1;
        int i = 0, start = 0;
        boolean match = false;
        boolean lastMatch = false;
        if (separatorChars == null) {
            while (i < len) {
                if (Character.isWhitespace(str.charAt(i))) {
                    if (match || preserveAllTokens) {
                        lastMatch = true;
                        if (sizePlus1++ == max) {
                            i = len;
                            lastMatch = false;
                        }
                        list.add(str.substring(start, i));
                        match = false;
                    }
                    start = ++i;
                    continue;
                }
                lastMatch = false;
                match = true;
                i++;
            }
        } else if (separatorChars.length() == 1) {
            char sep = separatorChars.charAt(0);
            while (i < len) {
                if (str.charAt(i) == sep) {
                    if (match || preserveAllTokens) {
                        lastMatch = true;
                        if (sizePlus1++ == max) {
                            i = len;
                            lastMatch = false;
                        }
                        list.add(str.substring(start, i));
                        match = false;
                    }
                    start = ++i;
                    continue;
                }
                lastMatch = false;
                match = true;
                i++;
            }
        } else {
            while (i < len) {
                if (separatorChars.indexOf(str.charAt(i)) >= 0) {
                    if (match || preserveAllTokens) {
                        lastMatch = true;
                        if (sizePlus1++ == max) {
                            i = len;
                            lastMatch = false;
                        }
                        list.add(str.substring(start, i));
                        match = false;
                    }
                    start = ++i;
                    continue;
                }
                lastMatch = false;
                match = true;
                i++;
            }
        }
        if (match || (preserveAllTokens && lastMatch)) {
            list.add(str.substring(start, i));
        }
        return (String[]) list.toArray(EMPTY_STRING_ARRAY);
    }

    /**
     * 消除转义字符
     * @param str
     * @return
     */
    public static String escapeXML(String str) {
        if (str == null)
            return "";
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); ++i) {
            char c = str.charAt(i);
            switch (c) {
            case '\u00FF':
            case '\u0024':
                break;
            case '&':
                sb.append("&amp;");
                break;
            case '<':
                sb.append("&lt;");
                break;
            case '>':
                sb.append("&gt;");
                break;
            case '\"':
                sb.append("&quot;");
                break;
            case '\'':
                sb.append("&apos;");
                break;
            default:
                if (c >= '\u0000' && c <= '\u001F')
                    break;
                if (c >= '\uE000' && c <= '\uF8FF')
                    break;
                if (c >= '\uFFF0' && c <= '\uFFFF')
                    break;
                sb.append(c);
                break;
            }
        }
        return sb.toString();
    }

    /**
     * 将字符串中特定模式的字符转换成map中对应的值
     *
     * @param s
     *            需要转换的字符串
     * @param map
     *            转换所需的键值对集合
     * @return 转换后的字符串
     */
    public static String replace(String s, Map<String, Object> map) {
        StringBuilder ret = new StringBuilder((int) (s.length() * 1.5));
        int cursor = 0;
        for (int start, end; (start = s.indexOf("${", cursor)) != -1 && (end = s.indexOf("}", start)) != -1;) {
            ret.append(s.substring(cursor, start)).append(map.get(s.substring(start + 2, end)));
            cursor = end + 1;
        }
        ret.append(s.substring(cursor, s.length()));
        return ret.toString();
    }

    public static String replace(String s, Object... objs) {
        if (objs == null || objs.length == 0)
            return s;
        if (s.indexOf("{}") == -1)
            return s;
        StringBuilder ret = new StringBuilder((int) (s.length() * 1.5));
        int cursor = 0;
        int index = 0;
        for (int start; (start = s.indexOf("{}", cursor)) != -1;) {
            ret.append(s.substring(cursor, start));
            if (index < objs.length)
                ret.append(objs[index]);
            else
                ret.append("{}");
            cursor = start + 2;
            index++;
        }
        ret.append(s.substring(cursor, s.length()));
        return ret.toString();
    }

    /**
     * 字符串格式化工具,参数必须以{0}之类的样式标示出来.大括号中的数字从0开始。
     * 
     * @param source
     *            源字符串
     * @param params
     *            需要替换的参数列表,写入时会调用每个参数的toString().
     * @return 替换完成的字符串。如果原始字符串为空或者参数为空那么将直接返回原始字符串。
     */
    public static String replaceArgs(String source, Object... params) {
        if (params == null || params.length == 0 || source == null || source.isEmpty()) {
            return source;
        }
        StringBuilder buff = new StringBuilder(source);
        StringBuilder temp = new StringBuilder();
        int startIndex = 0;
        int endIndex = 0;
        String param = null;
        for (int count = 0; count < params.length; count++) {
            if (params[count] == null) {
                param = null;
            } else {
                param = params[count].toString();
            }

            temp.delete(0, temp.length());
            temp.append("{");
            temp.append(count);
            temp.append("}");
            while (true) {
                startIndex = buff.indexOf(temp.toString(), endIndex);
                if (startIndex == -1) {
                    break;
                }
                endIndex = startIndex + temp.length();

                buff.replace(startIndex, endIndex, param == null ? "" : param);
            }
            startIndex = 0;
            endIndex = 0;
        }
        return buff.toString();
    }

    public static String substringBefore(final String s, final String separator) {
        if (isEmpty(s) || separator == null) {
            return s;
        }
        if (separator.isEmpty()) {
            return "";
        }
        final int pos = s.indexOf(separator);
        if (pos < 0) {
            return s;
        }
        return s.substring(0, pos);
    }

    public static String substringBetween(final String str, final String open, final String close) {
        if (str == null || open == null || close == null) {
            return null;
        }
        final int start = str.indexOf(open);
        if (start != -1) {
            final int end = str.indexOf(close, start + open.length());
            if (end != -1) {
                return str.substring(start + open.length(), end);
            }
        }
        return null;
    }

    public static String substringAfter(final String str, final String separator) {
        if (isEmpty(str)) {
            return str;
        }
        if (separator == null) {
            return "";
        }
        final int pos = str.indexOf(separator);
        if (pos == -1) {
            return "";
        }
        return str.substring(pos + separator.length());
    }

    /**
    * 自定义字符集转换为字节数组
    * @param str
    * @return 
    */
    public static String toString(byte[] bytes,String type){
      try {
          return new String(bytes, type);
        } catch (UnsupportedEncodingException e) {
          return null;
        }
    }

    /**
    * 自定义字符集转换为字节数组
    * @param str
    * @return 
    */
    public static byte[] getBytes(String str,String type){
      if (str != null){
        try {
            return str.getBytes(type);
          } catch (UnsupportedEncodingException e) {
            return null;
          }
      }else{
        return null;
      }
    }
    public static void main(String[] a){
        String escapeXML = escapeXML("\\");
        System.out.println(escapeXML);
        try {
			System.out.println(getUniqueString(36, true));
			System.out.println(getUniqueString(36, true));
			System.out.println(getUniqueString(36, true));
			System.out.println(getUniqueString(36, true));
			System.out.println(getUniqueString(36, true));
			System.out.println(replaceArgs("1{0}2{1}3{2}4{3}5{4}6{5}7{6}8{7}9", "a", "a", "a", "a", "a", "a", "a", "a"));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
}
